package cn.mujiankeji.mbrowser.界面.标签页.阅读页面

import android.annotation.SuppressLint
import android.webkit.JavascriptInterface
import cn.mujiankeji.mbrowser.app.应用接口
import cn.mujiankeji.mbrowser.app.应用操作.应用网页操作
import cn.mujiankeji.mbrowser.app.应用路由
import cn.mujiankeji.mbrowser.功能.浏览框.浏览框状态
import cn.mujiankeji.mbrowser.功能.浏览框.模型.浏览框页面配置
import cn.mujiankeji.mbrowser.工具.网络.网络操作
import cn.mujiankeji.mbrowser.数据.配置项.应用配置
import cn.mujiankeji.mbrowser.界面.小窗页.文本编辑窗口状态
import cn.mujiankeji.mbrowser.界面.框架.主视图.标签页状态
import cn.nr19.jian.E2Factory
import cn.nr19.jian.`object`.JianLei
import com.blankj.utilcode.util.ResourceUtils
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import org.jsoup.Jsoup
import org.jsoup.nodes.Element
import java.util.Locale

/**
 * @param 页面标题 进入阅读页面的网页标题
 * @param 页面地址 进入阅读页面的网页地址
 */
class 阅读页面状态(
    val 页面标题 : String,
    val 页面地址 : String,
    val 页面源码缓存标识 : String) : 标签页状态() {
    init {
        super.标题.value = "阅读 - ${页面标题}"
    }

    var coroutine : CoroutineScope ?= null
    var 浏览框 : 浏览框状态 = 浏览框状态(uuid = 标识,
        页面配置 = 浏览框页面配置("","",true,false),
        浏览框创建完毕 = {
            加载阅读器页面()
            false
        },
        响应状态更新 = {状态->

        },
        响应加载新的页面 = { url->
            应用路由.加载(url)
            true
        },
        响应可否加载文件 = { 地址 : String, 协议头 : Map<String,String>?->
            true
        },
        响应获取加载日记 = { listOf() },
        响应下载 = {url: String, userAgent: String?, contentDisposition: String?, mimetype: String?, contentLength: Long->
            应用网页操作.请求下载(url,userAgent, contentDisposition, mimetype, contentLength)
        },
        响应边缘颜色变化 = {顶部 : Int?,底部 : Int? -> },
        响应输入框 = {信息 : String,默认值 : String,回调 : (String?)->Unit ->
            文本编辑窗口状态(默认值,{信息}){
                回调(it)
            }.显示()
        },
        响应确认框 = {信息 : String,回调 : (Boolean)->Unit->
            应用接口.信息框(信息){
                回调(it)
            }
        },
        响应安装扩展或脚本 = {代码或地址 : String ->
            应用接口.安装扩展(代码或地址)
        },
        响应销毁页面 = {
            super.界面销毁()
        }
    )

    @SuppressLint("JavascriptInterface")
    fun 加载阅读器页面(){
        coroutine?.launch {
            浏览框.webview?.addJavascriptInterface(WebMx(),"reader")
            var code = ResourceUtils.readAssets2String("reader/index.html")
            code = code.replace("##head##","")
            code = code.replace("##body##","")
            浏览框.webview?.loadDataWithBaseURL(页面地址, code, "text/html", "UTF-8", null)

            delay(111)

            val el  = Jsoup.parse(读取源码()).body()
            if (el == null){
                设置正文内容("加载失败","<br><br>加载失败")
            }else{
                val title = 解析内容(el,"#title",".title","h1[class~=title]","[class~=articleTitle]","[class~=article-title]"
                    ,"[id~=title]","[class~=title]")

                val text = 解析内容(el,"#content","div.content","article",".main-read-container","div.wrap",
                    "[id~=article]","[class~=articleWrap]","[class~=article]","[class~=content]")

                设置正文内容(title,text)
            }
        }
    }

    /**
     * 解析HTML内容，读取正文
     */
    fun 解析内容(el : Element, vararg rules : String) : String{
        var content : Element?= null
        var index = 0
        while(content == null && index < rules.size){
            val rule = rules[index]
            if (rule.isNotEmpty()) {
                content = el.selectFirst(rules[index])

                if (content!=null) {
                    val t = 解析子内容(content)
                    if (t.trim().isEmpty()) {
                        content = null
                    }else{
                        return t
                    }
                }
            }
            index++
        }
        return 解析子内容(content?:el)
    }
    fun 解析子内容(el : Element) : String{
        var t = ""
        if (el.children().size == 0) return el.text().trim()

        for (child in el.children()) {
            when(child.tagName().lowercase(Locale.getDefault())){
                "h1","h2","h3","h4","h5" -> t += "<h3>${child.text().trim()}</h3>"
                "img" -> t += child.toString()
                "p" -> t += "<p>" + child.text().trim() + "</p>"
                "a" -> t += child.toString()
                "figcaption" -> t += "<figcaption>" + child.text().trim() + "</figcaption>"
                else -> {
                    if (child.text().trim().isNotEmpty() || child.select("img").size > 0) {
                        t += "<div>${解析子内容(child)}</div>"
                    }
                }
            }
        }
        return t
    }

    var 正文内容 = ""
    fun 设置正文内容(标题 : String,正文 : String){
        正文内容  = "<h3>${标题}</h3>" + 正文
        coroutine?.launch {
            浏览框.注入脚本("upContent()")
        }
    }


    suspend fun 读取源码() : String{
        return 应用接口.取缓存(页面源码缓存标识)
    }

    fun 翻译(){
        浏览框.注入翻译脚本()
    }

    override fun 界面暂停() {
        super.界面暂停()
        浏览框.暂停()
    }

    override fun 界面恢复() {
        super.界面恢复()
        浏览框.继续()
    }

    fun 跳转上一页(){

    }
    fun 跳转下一页(){

    }
    inner class WebMx(){
        @JavascriptInterface
        fun upHeadColor(color : String){
            // 背景色变化 -- ColorUtils.string2Int(color)
        }

        @JavascriptInterface
        fun goNext(){
            跳转上一页()
        }

        @JavascriptInterface
        fun goPrev(){
            跳转下一页()
        }

        @JavascriptInterface
        fun getContent() : String {
            return 正文内容
        }

        @JavascriptInterface
        fun getFontSize() : Int{
            return runBlocking { 应用配置.阅读器.字体大小().first() }
        }

        @JavascriptInterface
        fun upFontSize(i : Int){
            runBlocking {
                应用配置.阅读器.设置字体大小(i)
            }
        }

        @JavascriptInterface
        fun getVar(varSign : String): String {
            //return e2VarHelper?.getVar(varSign)
            return ""
        }


        @JavascriptInterface
        fun e2Rex(code : String,rule : String) : String{
            return E2Factory.text(code,rule,JianLei())
        }

        @JavascriptInterface
        fun getHttp(obj: String?): String {
            return runBlocking {
                网络操作.获取文本(obj?:return@runBlocking "") ?: ""
            }
        }

        @JavascriptInterface
        fun get1(url: String?) : String{
            return runBlocking {
                网络操作.获取文本(url?:return@runBlocking "") ?: ""
            }
        }
    }
}



